home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Multimedia / Resource Library: Multimedia.iso / utils / sound / players / unix / rplay / librplay.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-23  |  6.0 KB  |  323 lines
  1. /*
  2.  * librplay.c
  3.  *
  4.  * Copyright (c) 1992 by Mark Boyns
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software and its
  7.  * documentation for any purpose and without fee is hereby granted, provided
  8.  * that the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation.  This software is provided "as is" without express or
  11.  * implied warranty.
  12.  */
  13.  
  14. #include <sys/types.h>
  15. #include <sys/socket.h>
  16. #include <netinet/in.h>
  17. #include <netdb.h>
  18. #include <varargs.h>
  19. #include <malloc.h>
  20. #include <stdio.h>
  21. #include "version.h"
  22. #include "rplay.h"
  23.  
  24. int     rplay_errno;
  25.  
  26. char    *rplay_errlist[] = {
  27.     "no error",            /* RPLAY_ERROR_NONE */
  28.     "out of memory",        /* RPLAY_ERROR_MEMORY */
  29.     "host not found",        /* RPLAY_ERROR_HOST */
  30.     "rplay service not found",    /* RPLAY_ERROR_SERVICE */
  31.     "cannot connect to socket",    /* RPLAY_ERROR_CONNECT */
  32.     "cannot create socket",        /* RPLAY_ERROR_SOCKET */
  33.     "unknown rplay attribute",    /* RPLAY_ERROR_ATTRIBUTE */
  34.     "error writing to socket",    /* RPLAY_ERROR_WRITE */
  35.     "error closing socket",        /* RPLAY_ERROR_CLOSE */ 
  36.     "append error",            /* RPLAY_ERROR_APPEND */
  37.     "max packet size exceeded",    /* RPLAY_ERROR_PACKET_SIZE */
  38.     "cannot enable broadcast",    /* RPLAY_ERROR_BROADCAST */
  39. };
  40.  
  41. /*
  42.  * macro used to gradually increase an rplay buffer by COPY_SIZE bytes
  43.  */
  44. #define COPY_SIZE    128
  45. #define COPY(rp, ptr, n) \
  46.     rp->grow = 0; \
  47.     while(rp->len + n > rp->size) { \
  48.         rp->grow = 1; \
  49.         rp->size += COPY_SIZE; \
  50.         if (rp->size > MAX_PACKET) { \
  51.             rplay_errno = RPLAY_ERROR_PACKET_SIZE; \
  52.             return -1; \
  53.         } \
  54.     } \
  55.     if (rp->grow) { \
  56.         rp->buf = realloc(rp->buf, rp->size); \
  57.         if (rp->buf == NULL) { \
  58.             rplay_errno =  RPLAY_ERROR_MEMORY; \
  59.             return -1; \
  60.         } \
  61.     } \
  62.     bcopy(ptr, rp->buf+rp->len, n); \
  63.     rp->len += n; \
  64.  
  65. /*
  66.  * create an RPLAY instance
  67.  */
  68. RPLAY    *rplay_create()
  69. {
  70.     RPLAY    *rp;
  71.  
  72.     rplay_errno = RPLAY_ERROR_NONE;
  73.  
  74.     rp = (RPLAY *)malloc(sizeof(RPLAY));
  75.     if (rp == NULL) {
  76.         rplay_errno =  RPLAY_ERROR_MEMORY;
  77.         return NULL;
  78.     }
  79.     else {
  80.         rp->len = 0; 
  81.         rp->buf = (char *)malloc(COPY_SIZE);
  82.         if (rp->buf == NULL) {
  83.             rplay_errno =  RPLAY_ERROR_MEMORY;
  84.             return NULL;
  85.         }
  86.         rp->size = COPY_SIZE;
  87.         return rp;
  88.     }
  89. }
  90.  
  91. /*
  92.  * free up memory used by rp
  93.  */
  94. int    rplay_destroy(rp) 
  95. RPLAY    *rp;
  96. { 
  97.     free(rp->buf);
  98.     free(rp);    
  99. } 
  100.  
  101. /*
  102.  * set rplay attributes
  103.  */
  104. int    rplay_set(va_alist)
  105. va_dcl
  106. {
  107.     va_list        args;
  108.     RPLAY        *rp;
  109.     char        *p;
  110.     unsigned char    val, *valp = &val;
  111.     int        attr, append;
  112.  
  113.     rplay_errno = RPLAY_ERROR_NONE;
  114.  
  115.     va_start(args);
  116.     rp = va_arg(args, RPLAY *);
  117.     attr = va_arg(args, int); 
  118.  
  119.     append = 0;
  120.     switch(attr) {
  121.     case RPLAY_APPEND_PLAY:
  122.         if (rp->len <= 0 || rp->buf[0] != RPLAY_PLAY) {
  123.             rplay_errno = RPLAY_ERROR_APPEND;
  124.             return -1;
  125.         }
  126.         attr = RPLAY_PLAY;
  127.         append = 1;
  128.         break;
  129.  
  130.     case RPLAY_APPEND_PAUSE:
  131.         if (rp->len <= 0 || rp->buf[0] != RPLAY_PAUSE) {
  132.             rplay_errno = RPLAY_ERROR_APPEND;
  133.             return -1;
  134.         }
  135.         attr = RPLAY_PAUSE;
  136.         append = 1;
  137.         break;
  138.  
  139.     case RPLAY_APPEND_STOP: 
  140.         if (rp->len <= 0 || rp->buf[0] != RPLAY_STOP) {
  141.             rplay_errno = RPLAY_ERROR_APPEND;
  142.             return -1;
  143.         }
  144.         attr = RPLAY_STOP;
  145.         append = 1;
  146.         break;
  147.  
  148.     case RPLAY_APPEND_CONTINUE:
  149.         if (rp->len <= 0 || rp->buf[0] != RPLAY_CONTINUE) {
  150.             rplay_errno = RPLAY_ERROR_APPEND;
  151.             return -1;
  152.         }
  153.         attr = RPLAY_CONTINUE;
  154.         append = 1;
  155.         break;
  156.  
  157.     case RPLAY_APPEND_VOLUME_PLAY:
  158.         if (rp->len <= 0 || rp->buf[0] != RPLAY_PLAY) {
  159.             rplay_errno = RPLAY_ERROR_APPEND;
  160.             return -1;
  161.         }
  162.         attr = RPLAY_VOLUME_PLAY;
  163.         append = 1;
  164.         break;
  165.     }
  166.  
  167.     if (append) {
  168.         rp->len--;
  169.     }
  170.     else {
  171.         rp->len = 0;
  172.     }
  173.  
  174.     switch(attr) {  
  175.     case RPLAY_PLAY:
  176.     case RPLAY_PAUSE:
  177.     case RPLAY_STOP: 
  178.     case RPLAY_CONTINUE:
  179.     case RPLAY_VOLUME_PLAY:
  180.         if (!append) {
  181.             *valp = attr == RPLAY_VOLUME_PLAY ? RPLAY_PLAY : attr;
  182.             COPY(rp, valp, 1);
  183.         }
  184.         for(;;) {
  185.             p = va_arg(args, char *);
  186.             if (p == NULL) {
  187.                 *valp = NULL;
  188.                 COPY(rp, valp, 1);
  189.                 break;
  190.             }
  191.             COPY(rp, p, strlen(p)+1);
  192.             if (attr == RPLAY_VOLUME_PLAY) {
  193.                 *valp = (unsigned char)va_arg(args, int);
  194.                 COPY(rp, valp, 1);
  195.             } 
  196.             else if (attr == RPLAY_PLAY) {
  197.                 *valp = RPLAY_DEFAULT_VOLUME;
  198.                 COPY(rp, valp, 1);
  199.             }
  200.         }
  201.         break; 
  202.          
  203.     default:
  204.         rplay_errno = RPLAY_ERROR_ATTRIBUTE;
  205.         return -1;
  206.     } 
  207.  
  208.     va_end(args);
  209.  
  210.     return 0;
  211. }
  212.  
  213. /*
  214.  * create a UDP socket for the given host
  215.  */
  216. int    rplay_open(host)
  217. char    *host;
  218. {
  219.     struct hostent        *hp;
  220. #ifdef INETD
  221.     struct servent        *sp;
  222. #endif INETD
  223.     int            rplay_fd;
  224.     u_long            addr;
  225.     struct sockaddr_in    s;
  226.     int            on = 1;
  227.  
  228.     rplay_errno = RPLAY_ERROR_NONE;
  229.  
  230. #ifdef INETD
  231.     sp = getservbyname("rplay", "udp");
  232.     if (sp == NULL) {
  233.         rplay_errno = RPLAY_ERROR_SERVICE;
  234.         return -1;
  235.     }
  236. #endif INETD
  237.  
  238.     bzero(&s, sizeof(s));
  239.  
  240.     addr = inet_addr(host);
  241.     if (addr == 0xffffffff) {
  242.         hp = gethostbyname(host);
  243.         if (hp == NULL) {
  244.             rplay_errno = RPLAY_ERROR_HOST;
  245.             return -1;
  246.         }
  247.         bcopy(hp->h_addr, &s.sin_addr.s_addr, hp->h_length);
  248.     }
  249.     else {
  250.         bcopy(&addr, &s.sin_addr.s_addr, sizeof(addr));
  251.     }
  252.  
  253. #ifdef INETD
  254.     s.sin_port = sp->s_port;
  255. #else
  256.     s.sin_port = htons(RPLAY_PORT);
  257. #endif INETD
  258.     s.sin_family = AF_INET;
  259.  
  260.     rplay_fd = socket(AF_INET, SOCK_DGRAM, 0);
  261.     if (rplay_fd < 0) {
  262.         rplay_errno = RPLAY_ERROR_SOCKET;
  263.         return -1;
  264.     }
  265.  
  266.     if (connect(rplay_fd, &s, sizeof(s)) < 0) {
  267.         rplay_errno = RPLAY_ERROR_CONNECT;
  268.         return -1;
  269.     }
  270.  
  271.     /*
  272.      * enable broadcasting
  273.      */
  274.     if (setsockopt(rplay_fd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) {
  275.         rplay_errno = RPLAY_ERROR_BROADCAST;
  276.         return -1;
  277.     }
  278.  
  279.     return rplay_fd;
  280. }
  281.  
  282. /*
  283.  * write the RPLAY packet to the given socket descriptor
  284.  */
  285. int    rplay(rplay_fd, rp)
  286. int    rplay_fd;
  287. RPLAY    *rp;
  288. {
  289.     rplay_errno = RPLAY_ERROR_NONE;
  290.  
  291.     if (write(rplay_fd, rp->buf, rp->len) != rp->len) {
  292.         rplay_errno = RPLAY_ERROR_WRITE;
  293.         return -1;
  294.     }
  295.  
  296.     return 0;
  297. }
  298.  
  299. /*
  300.  * close the given rplay socket descriptor
  301.  */
  302. int    rplay_close(rplay_fd)
  303. int    rplay_fd;
  304. {
  305.     rplay_errno = RPLAY_ERROR_NONE;
  306.  
  307.     if (close(rplay_fd) < 0) {
  308.         rplay_errno = RPLAY_ERROR_CLOSE;
  309.         return -1;
  310.     }
  311.  
  312.     return 0;
  313. }
  314.  
  315. /*
  316.  * report an rplay error to stderr
  317.  */
  318. rplay_perror(s)
  319. char    *s;
  320. {
  321.     fprintf(stderr, "%s: %s\n", s, rplay_errlist[rplay_errno]);
  322. }
  323.